#!/usr/bin/python3
# -*- coding:utf-8 -*-
#######################################################
# Author: liangliangSu
# Created Time: 2023-09-07 21:24
# Email: sll917@outlook.com
# Version: V1.0
# File Name: 14条件控制.py
#######################################################
print('(1)------------------完美分割线---------------------')
#Python 条件语句是通过一条或多条语句的执行结果（True 或者 False）来决定执行的代码块
#可以通过下图来简单了解条件语句的执行过程:
#代码执行过程：
#if 语句
#Python中if语句的一般形式如下所示：
"""
if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

如果 "condition_1" 为 True 将执行 "statement_block_1" 块语句
如果 "condition_1" 为False，将判断 "condition_2"
如果"condition_2" 为 True 将执行 "statement_block_2" 块语句
如果 "condition_2" 为False，将执行"statement_block_3"块语句
Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。
注意：
1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
3、在Python中没有switch – case语句。

以下为if中常用的操作运算符:
操作符	描述
<	小于
<=	小于或等于
>	大于
>=	大于或等于
==	等于，比较两个值是否相等
!=	不等于

if 嵌套
在嵌套 if 语句中，可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中
if 表达式1:
    语句
    if 表达式2:
        语句
    elif 表达式3:
        语句
    else:
        语句
elif 表达式4:
    语句
else:
    语句
"""

b = []
if not b:
    print("空的列表是false")

c = "False"  # 非空字符串也是：True
if c:
    print("c")

d = 10
if d:
    print("d")

if 3 < d < 100:
    print("3<d<100")

# if 3<c and (c=20):  条件表达式不能使用“赋值操作符”
s = input("请输入一个数字：")

if int(s) < 10:
    print("s是小于10的数字")
else:
    print("s是大于等于10的数字")

# 测试三元条件运算符
print("s是小于10的数字" if int(s) < 10 else "s是大于等于10的数字")

# 测试多分支选择结构
print('(2)------------------完美分割线---------------------')

score = int(input("请输入分数："))
grade = ""

if score < 60:
    grade = "不及格"
elif score < 80:  # 60-80之间
    grade = "及格"
elif score < 90:
    grade = "良好"
else:
    grade = "优秀"

print("分数是{0}，等级是{1}".format(score, grade))

# 测试选择结构的嵌套
# 输入一个分数。分数在0-100之间。90以上是A,80以上是B，70以上是C，60以上是D。60以下是E。

score = int(input("请输入一个在0-100之间的数字："))
grade = ""
if score > 100 or score < 0:
    score = int(input("输入错误！请重新输入一个在0-100之间的数字："))
else:
    if score >= 90:
        grade = "A"
    elif score >= 80:
        grade = 'B'
    elif score >= 70:
        grade = 'C'
    elif score >= 60:
        grade = 'D'
    else:
        grade = 'E'
    print("分数为{0},等级为{1}".format(score, grade))

print('(3)------------------完美分割线---------------------')

#实例
num=int(input("输入一个数字："))
if num%2 == 0:
    if num%3 == 0:
        print ("你输入的数字可以整除 2 和 3")
    else:
        print ("你输入的数字可以整除 2，但不能整除 3")
else:
    if num%3 == 0:
        print ("你输入的数字可以整除 3，但不能整除 2")
    else:
        print  ("你输入的数字不能整除 2 和 3")
#输入一个数字：6
#你输入的数字可以整除 2 和 3

print('(4)------------------完美分割线---------------------')
score = int(input("请输入一个在0-100之间的数字："))
degree = "ABCDE"
num = 0
if score > 100 or score < 0:
    score = int(input("输入错误！请重新输入一个在0-100之间的数字："))
else:
    num = score // 10
    if num < 6: num = 5

    print("分数是{0},等级是{1}".format(score, degree[9 - num]))

print('(5)------------------完美分割线---------------------')
# 测试while循环
num = 0
while num <= 10:
    print(num, end="\t")
    num += 1

print('(6)------------------完美分割线---------------------')
# 计算1-100之间数字的累加和
num2 = 0
sum_all = 0

while num2 <= 100:
    sum_all = sum_all + num2
    num2 += 1
print("1-100所有书的累加和：", sum_all)

# 测试for循环
"""
for 循环和可迭代对象遍历
for 循环通常用于可迭代对象的遍历。for 循环的语法格式如下：
for 变量in 可迭代对象：
    循环体语句
【操作】遍历一个元组或列表
for x in (20,30,40):
print(x*3)
可迭代对象
Python 包含以下几种可迭代对象：
1. 序列 (包含：字符串、列表、元组)
2. 字典
3. 迭代器对象（iterator）
4. 生成器函数（generator）
5. 文件对象
"""

print('(7)------------------完美分割线---------------------')
for x in (10, 20, 30):
    print(x * 30)

for y in "abcdef":
    print(y)

d = {"name": "高淇", "age": 18, "job": "程序员"}
for x in d:
    print(x)
for x in d.keys():
    print(x)
for x in d.values():
    print(x)
for x in d.items():
    print(x)
for x in range(5):
    print(x)

print('(8)------------------完美分割线---------------------')
sum_all = 0
sum_odd = 0  # 100以内的奇数和
sum_even = 0  # 100以内的偶数和
for x in range(101):
    sum_all += x
    if x % 2 == 1:
        sum_odd += x
    else:
        sum_even += x
print("1-100累加总和{0},奇数和{1},偶数和{2}".format(sum_all, sum_odd, sum_even))

# 测试嵌套循环
print('(9)------------------完美分割线---------------------')
for x in range(5):
    for y in range(5):
        print(x, end="\t")
    print()  # 起到换行的作用

print('(10)------------------完美分割线---------------------')
# 打印九九乘法表
for m in range(1, 10):
    for n in range(1, m + 1):
        print("{0}*{1}={2}".format(m, n, (m * n)), end="\t")
    print()  # 换行

print('(11)------------------完美分割线---------------------')
# 用列表和字典存储下表信息，并打印出表中工资高于15000 的数据
r1 = dict(name="徐达", age=18, salary=30000, city="北京")
r2 = dict(name="程咬金", age=19, salary=20000, city="上海")
r3 = dict(name="岳飞", age=20, salary=10000, city="深圳")
tb = [r1, r2, r3]
for x in tb:
    if x.get("salary") > 15000:
        print("工资高于15000的人有：{}".format(x.get("name")))
# 测试break
while True:
    a = input("请输入一个字符（输入Q或q时退出）：")
    if a == "q" or a == "Q":
        print("循环结束，退出")
        break
    else:
        print(a)
empNum = 0
salarySum = 0
salarys = []
while True:
    s = input("请输入员工的薪资（按Q或q结束）")

    if s.upper() == 'Q':
        print("录入完成，退出")
        break
    if float(s) < 0:
        continue
    empNum += 1
    salarys.append(float(s))
    salarySum += float(s)

print("员工数{0}".format(empNum))
print("录入薪资：", salarys)
print("平均薪资{0}".format(salarySum / empNum))

# 测试循环中的else语句
# else 语句
# while、for 循环可以附带一个else 语句（可选）。如果for、while 语句没有被break 语句
# 结束，则会执行else 子句，否则不执行。语法格式如下：
"""
while 条件表达式：
    循环体
else:
    语句块
或者：
for 变量in 可迭代对象：
    循环体
else:
     语句块
"""

# 【操作】员工一共4 人。录入这4 位员工的薪资。全部录入后，打印提示“您已经全部录
# 入4 名员工的薪资”。最后，打印输出录入的薪资和平均薪资
print('(12)------------------完美分割线---------------------')
salarySum = 0
salarys = []
for i in range(4):
    s = input("请输入一共4名员工的薪资（按Q或q中途结束）")

    if s.upper() == 'Q':
        print("录入完成，退出")
        break
    if float(s) < 0:
        continue

    salarys.append(float(s))
    salarySum += float(s)

else:
    print("您已经全部录入4名员工的薪资")

print("录入薪资：", salarys)
print("平均薪资{0}".format(salarySum / 4))

# 循环代码优化测试
# 虽然计算机越来越快，空间也越来越大，我们仍然要在性能问题上“斤斤计较”。编写循环
# 时，遵守下面三个原则可以大大提高运行效率，避免不必要的低效计算：
# 1. 尽量减少循环内部不必要的计算
# 2. 嵌套循环中，尽量减少内层循环的计算，尽可能向外提。
# 3. 局部变量查询较快，尽量使用局部变量
print('(13)------------------完美分割线---------------------')
import time

start = time.time()
for i in range(1000):
    result = []
    for m in range(10000):
        result.append(i * 1000 + m * 100)

end = time.time()
print("耗时方案1：{0}".format((end - start)))

start2 = time.time()
for i in range(1000):
    result = []
    c = i * 1000
    for m in range(10000):
        result.append(c + m * 100)

end2 = time.time()
print("耗时方案2：{0}".format((end2 - start2)))

# 测试zip()并行迭代
# 我们可以通过zip()函数对多个序列进行并行迭代，zip()函数在最短序列“用完”时就会停
print('(14)------------------完美分割线---------------------')
for i in [1, 2, 3]:
    print(i)
print('(15)------------------完美分割线---------------------')
names = ("高淇", "高老二", "高老三", "高老四")
ages = (18, 16, 20, 25)
jobs = ("老师", "程序员", "公务员")
for name, age, job in zip(names, ages, jobs):
    print("{0}--{1}--{2}".format(name, age, job))

print('(16)------------------完美分割线---------------------')
for i in range(3):
    print("{0}--{1}--{2}".format(names[i], ages[i], jobs[i]))

# 测试推导式
# 推导式是从一个或者多个迭代器快速创建序列的一种方法。它可以将循环和条件判断结合，
# 从而避免冗长的代码。推导式是典型的Python 风格，
# 会使用它代表你已经超过Python 初学者的水平.

# 列表推导式
# 列表推导式生成列表对象，语法如下：
"""
[表达式for item in 可迭代对象]
或者：{表达式for item in 可迭代对象  if 条件判断}
"""
print('(17)------------------完美分割线---------------------')
y = [x * 2 for x in range(1, 30) if x % 5 == 0]
print(y)

print('(18)------------------完美分割线---------------------')
y = []
for x in range(1, 50):
    if x % 5 == 0:
        y.append(x * 2)
print(y)

print('(19)------------------完美分割线---------------------')
cells = [(row, col) for row in range(1, 5) for col in range(1, 5)]
print(cells)

# 字典推导式
# 字典的推导式生成字典对象，格式如下：
"""
{key_expression : value_expression for 表达式in 可迭代对象}
"""
# 类似于列表推导式，字典推导也可以增加if 条件判断、多个for 循环.
print('(19)------------------完美分割线---------------------')
my_text = "i love you, i love sxt, i love gaoqi"
char_count = {i: my_text.count(i) for i in my_text}
print(char_count)

# 集合推导式
# 集合推导式生成集合，和列表推导式的语法格式类似：
"""
{表达式for item in 可迭代对象}
或者：{表达式for item in 可迭代对象if 条件判断}
"""
print('(19)------------------完美分割线---------------------')
b = {x for x in range(1, 100) if x % 9 == 0}
print(b)

# 生成器推导式（生成元组）
gnt = (x for x in range(4))
print(tuple(gnt))

for x in gnt:  # gnt是生成器对象，生成器是可迭代的对象，只能使用一次
    print(x, end=",")
print(tuple(gnt))
import turtle

t = turtle.Pen()

my_colors = ("red", "green", "yellow", "black")

t.width(4)
t.speed(1)
for i in range(10):  # 0   1    2    3    4
    t.penup()
    t.goto(0, -i * 10)  # 0, -100,-200,-300,-400
    t.pendown()
    t.color(my_colors[i % len(my_colors)])
    t.circle(15 + i * 10)  # 100,200,300, 400, 500

turtle.done()  # 程序执行完，窗口仍然在
# 画棋盘
import turtle

width = 30
num = 18

x1 = [(-400, 400), (-400 + width * num, 400)]
y1 = [(-400, 400), (-400, 400 - width * num)]
t = turtle.Pen()
t.speed(10)
# t.goto(x1[0][0],x1[0][1])
# t.goto(x1[1][0],x1[1][1])

for i in range(0, 19):
    t.penup()
    t.goto(x1[0][0], x1[0][1] - 30 * i)
    t.pendown()
    t.goto(x1[1][0], x1[1][1] - 30 * i)

for i in range(0, 19):
    t.penup()
    t.goto(y1[0][0] + 30 * i, y1[0][1])
    t.pendown()
    t.goto(y1[1][0] + 30 * i, y1[1][1])

t.hideturtle()  # 隐藏画笔
turtle.done()  # 保证运行窗口不被自动关闭

